package qc.module.ehs.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import qc.common.core.exception.QCPromptException;
import qc.common.core.unify.QCUnifyReturnValue;
import qc.common.core.utils.IdentifierUtil;
import qc.module.ehs.dto.templatehazard.TplHazardItemDto;
import qc.module.ehs.entity.EhsTplHazardcategory;
import qc.module.ehs.entity.EhsTplHazarditem;
import qc.module.ehs.entity.EhsTplHazardproject;
import qc.module.ehs.mapper.EhsTplHazarditemMapper;
import qc.module.ehs.repository.EhsTplHazardcategoryRepository;
import qc.module.ehs.repository.EhsTplHazarditemRepository;
import qc.module.ehs.repository.EhsTplHazardprojectRepository;

import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * 危险源清单接口Service
 *
 * @author QuCheng Tech
 * @create 2024/5/22
 */
@Service
public class EhsTplHazarditemService {
    
    private EhsTplHazarditemRepository repository;

    @Autowired
    public void setRepository(EhsTplHazarditemRepository repository) {
        this.repository = repository;
    }
    
    @Autowired
    private EhsTplHazardprojectRepository hazardprojectRepository;
    
    @Autowired
    private EhsTplHazardcategoryRepository hazardcategoryRepository;

    /**
     * 获取指定危险源项目中的清单
     *
     * @param hpjtcd 危险源项目代码
     * @return List<TplHazardItemDto>
     * @author QuCheng Tech
     * @since 2024/5/23
     */
    public List<TplHazardItemDto> getProjectItems(String hpjtcd) throws QCPromptException {
        if (StringUtils.isBlank(hpjtcd)) throw new QCPromptException("危险源项目代码不能为空");

        LambdaQueryWrapper<EhsTplHazarditem> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsTplHazarditem::getHpjtcd,hpjtcd);
        wrapper.orderByAsc(EhsTplHazarditem::getHicd);
        List<EhsTplHazarditem> ens = repository.selectList(wrapper);
        
        if (CollectionUtils.isNotEmpty(ens)){
            return EhsTplHazarditemMapper.MAPPER.toDtoList(ens);
        }
        return null;
    }

    /**
     * 获取指定危险源清单
     *
     * @param id 危险源清单代码
     * @return TplHazardItemDto
     * @author QuCheng Tech
     * @since 2024/5/23
     */
    public TplHazardItemDto getItem(String id) throws QCPromptException {
        if (StringUtils.isBlank(id)) throw new QCPromptException("危险源清单代码不能为空");
        
        EhsTplHazarditem en = repository.selectById(id);
        
        if (Objects.nonNull(en)){
            return EhsTplHazarditemMapper.MAPPER.toDto(en);
        }
        return null;
    }

    /**
     * 批量获取指定危险源清单列表
     * 
     * @param ids 危险源清单ID集合
     * @return List<TplHazardItemDto>
     * @author QuCheng Tech
     * @since 2024/8/20
     */
    public List<TplHazardItemDto> getItems(List<String> ids){
        
        List<EhsTplHazarditem> items = repository.selectBatchIds(ids);
        if (CollectionUtils.isNotEmpty(items)){
            return EhsTplHazarditemMapper.MAPPER.toDtoList(items);
        }
        return null;
    }

    /**
     * 新增指定危险源清单
     *
     * @param dto 危险源清单信息
     * @param isImportDB 是否为导入时添加
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/5/23
     */
    public String addItem(TplHazardItemDto dto,boolean isImportDB){
        //1.清单信息判空
        if (dto == null) return QCUnifyReturnValue.Warn("危险源清单信息不能为空");
        //if (StringUtils.isBlank(dto.getHicd())) return QCUnifyReturnValue.Warn("危险源清单代码不能为空");
        if (StringUtils.isBlank(dto.getHinm())) return QCUnifyReturnValue.Warn("危险源清单名称不能为空");
        if (StringUtils.isBlank(dto.getHpjtcd())) return QCUnifyReturnValue.Warn("危险源项目代码不能为空");
        if (dto.getIsmajor() == null) return QCUnifyReturnValue.Warn("是否为重大危险源不能为空");
        
        //2.判断危险源清单代码是否存在，存在则提示
        //if (hicdIsExist(dto.getHicd())) return QCUnifyReturnValue.Warn("危险源清单代码已经存在");
        
        //3.判断危险源项目代码是否存在，不存在则提示
        EhsTplHazardproject project = hazardprojectRepository.selectById(dto.getHpjtcd());
        if (Objects.isNull(project)) return QCUnifyReturnValue.Warn("危险源项目代码不存在");
        
        //4.dto转为entity
        EhsTplHazarditem en = EhsTplHazarditemMapper.MAPPER.toEntity(dto);
        if (!isImportDB) en.setHicd(IdentifierUtil.randomUUID());
        
        //5.保存数据
        if (repository.insert(en) < 0x1){
            return QCUnifyReturnValue.Warn("保存失败");
        }
        return QCUnifyReturnValue.Success();
    }

    /**
     * 修改指定危险源清单
     *
     * @param dto 危险源清单信息
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/5/23
     */
    public String updateItem(TplHazardItemDto dto){
        //1.清单信息判空
        if (dto == null) return QCUnifyReturnValue.Warn("危险源清单信息不能为空");
        if (StringUtils.isBlank(dto.getHicd())) return QCUnifyReturnValue.Warn("危险源清单代码不能为空");
        if (StringUtils.isBlank(dto.getHinm())) return QCUnifyReturnValue.Warn("危险源清单名称不能为空");
        if (StringUtils.isBlank(dto.getHpjtcd())) return QCUnifyReturnValue.Warn("危险源项目代码不能为空");
        if (dto.getIsmajor() == null) return QCUnifyReturnValue.Warn("是否为重大危险源不能为空");

        //2.判断危险源清单代码是否存在，不存在则提示
        if (!hicdIsExist(dto.getHicd())) return QCUnifyReturnValue.Warn("危险源清单代码不存在");

        //3.判断危险源项目代码是否存在，不存在则提示
        EhsTplHazardproject project = hazardprojectRepository.selectById(dto.getHpjtcd());
        if (Objects.isNull(project)) return QCUnifyReturnValue.Warn("危险源项目代码不存在");

        //4.dto转为entity
        EhsTplHazarditem en = EhsTplHazarditemMapper.MAPPER.toEntity(dto);
        
        //5.更新数据
        repository.updateById(en);
        return QCUnifyReturnValue.Success();
    }

    /**
     * 删除指定危险源清单 - 同时支持@RequestParam与@PathVariable方式
     *
     * @param id 危险源清单代码
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/5/23
     */
    public String deleteItem(String id){
        if (StringUtils.isBlank(id)) return QCUnifyReturnValue.Warn("危险源清单代码不能为空");
        
        repository.deleteById(id);
        return QCUnifyReturnValue.Success();
    }

    /**
     * 判断指定危险源清单代码是否存在
     * 
     * @param id 危险源清单代码
     * @return true表示存在，false表示不存在
     * @author QuCheng Tech
     * @since 2024/5/23
     */
    public boolean hicdIsExist(String id){
        EhsTplHazarditem en = repository.selectById(id);
        if (Objects.nonNull(en)){
            return true;
        }
        return false;
    }

    /**
     * 获取清单中的项目代码集合
     *
     * @return List<String>
     * @author QuCheng Tech
     * @since 2024/5/24
     */
    public List<String> getHpjtcds(){
        LambdaQueryWrapper<EhsTplHazarditem> wrapper = new LambdaQueryWrapper<>();
        wrapper.select(EhsTplHazarditem::getHpjtcd);
        List<EhsTplHazarditem> ens = repository.selectList(wrapper);
        if (CollectionUtils.isNotEmpty(ens)){
            List<String> hpjtcds = ens.stream().map(EhsTplHazarditem::getHpjtcd).collect(Collectors.toList());
            return hpjtcds.stream().distinct().collect(Collectors.toList());
        }
        return null;
    }
    
    /**
     * 获取指定导则库的危险源清单
     *
     * @param hdbcd 导则库ID
     * @return List<TplHazardItemDto>
     * @author QuCheng Tech
     * @since 2024/6/28
     */
    public  List<TplHazardItemDto> getHdbcdItems(String hdbcd) throws QCPromptException {
        if (StringUtils.isBlank(hdbcd)) throw new QCPromptException("导则库ID不能为空");

        //1.根据导则库ID获取危险源类别
        LambdaQueryWrapper<EhsTplHazardcategory> categoryWrapper = new LambdaQueryWrapper<>();
        categoryWrapper.eq(EhsTplHazardcategory::getHdbcd,hdbcd);
        List<EhsTplHazardcategory> categories = hazardcategoryRepository.selectList(categoryWrapper);
        if (CollectionUtils.isNotEmpty(categories)){
            List<String> categoryIds = categories.stream().map(EhsTplHazardcategory::getHcatcd).collect(Collectors.toList());

            //2.根据类别ID集合查询危险源项目
            LambdaQueryWrapper<EhsTplHazardproject> projectWrapper = new LambdaQueryWrapper<>();
            projectWrapper.in(EhsTplHazardproject::getHcatcd,categoryIds);
            List<EhsTplHazardproject> projects = hazardprojectRepository.selectList(projectWrapper);
            if (CollectionUtils.isNotEmpty(projects)){
                List<String> projectIds = projects.stream().map(EhsTplHazardproject::getHpjtcd).collect(Collectors.toList());

                //3.根据项目ID集合查询危险源清单
                LambdaQueryWrapper<EhsTplHazarditem> itemWrapper = new LambdaQueryWrapper<>();
                itemWrapper.in(EhsTplHazarditem::getHpjtcd,projectIds);
                List<EhsTplHazarditem> items = repository.selectList(itemWrapper);
                if (CollectionUtils.isNotEmpty(items)){
                    return EhsTplHazarditemMapper.MAPPER.toDtoList(items);
                }

            }
        }

        return null;
    }
    
}

